#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<numeric>
#include<string>
#include<algorithm>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
    
};

class Solution {
public:
    int count = 0, ret = 0;
    int kthSmallest(TreeNode* root, int k) {
        count = k;
        dfs(root);
        return ret;
    }
    void dfs(TreeNode* root)
    {
        if (root == nullptr || count == 0) return;
        dfs(root->left);
        --count;
        if (count == 0) ret = root->val;
        dfs(root->right);
    }

    int searchInsert(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left < right)
        {
            int m = left + ((right - left) >> 1);
            if (nums[m] >= target) right = m;
            else if (nums[m] < target) left = m + 1;
        }
        if (nums[left] < target) left = nums.size();
        return left;
    }

    vector<int> bucket;
    bool canPartitionKSubsets(vector<int>& nums, int k) {
        if (k > nums.size()) return false;
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % k != 0) return false;
        sort(nums.rbegin(), nums.rend());
        bucket.resize(k);
        int target = sum / k;
        return backtrack(nums, 0, target);
    }
    bool backtrack(vector<int>& nums, size_t index, int target)
    {
        if (index == nums.size())
        {
            for (int i = 0; i < bucket.size(); ++i)
            {
                if (bucket[i] != target) return false;
            }
            return true;
        }

        for (int i = 0; i < bucket.size(); ++i)
        {
            if (bucket[i] + nums[index] > target) continue;
            if (i > 0 && bucket[i] == bucket[i - 1]) continue;
            bucket[i] += nums[index];
            if (backtrack(nums, index + 1, target)) return true;
            bucket[i] -= nums[index];
        }
        return false;
    }

    bool isAE(int n1, int n2)
    {
        if (n1 == n2) return true;
        string s1 = to_string(n1), s2 = to_string(n2);
        for (size_t m = 0; m < s2.size() - 1; ++m)
        {
            for (int n = 1; n < s2.size(); ++n)
            {
                char tmp = s2[m];
                s2[m] = s2[n];
                s2[n] = tmp;
                if (stoi(s1) == stoi(s2)) return true;
                tmp = s2[m];
                s2[m] = s2[n];
                s2[n] = tmp;
            }
        }
        return false;
    }
    int countPairs(vector<int>& nums) {
        int ans = 0;
        sort(nums.begin(), nums.end());
        for (size_t i = 0; i < nums.size() - 1; ++i)
        {
            for (int j = i + 1; j < nums.size(); ++j)
            {
                if (isAE(nums[i], nums[j])) ++ans;
            }
        }
        return ans;
    }
};

int main()
{
    string s("001");
    int n = stoi(s);
    cout << n << endl;
}
